home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_iterlen.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  10KB  |  271 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. """ Test Iterator Length Transparency
  5.  
  6. Some functions or methods which accept general iterable arguments have
  7. optional, more efficient code paths if they know how many items to expect.
  8. For instance, map(func, iterable), will pre-allocate the exact amount of
  9. space required whenever the iterable can report its length.
  10.  
  11. The desired invariant is:  len(it)==len(list(it)).
  12.  
  13. A complication is that an iterable and iterator can be the same object. To
  14. maintain the invariant, an iterator needs to dynamically update its length.
  15. For instance, an iterable such as xrange(10) always reports its length as ten,
  16. but it=iter(xrange(10)) starts at ten, and then goes to nine after it.next().
  17. Having this capability means that map() can ignore the distinction between
  18. map(func, iterable) and map(func, iter(iterable)).
  19.  
  20. When the iterable is immutable, the implementation can straight-forwardly
  21. report the original length minus the cumulative number of calls to next().
  22. This is the case for tuples, xrange objects, and itertools.repeat().
  23.  
  24. Some containers become temporarily immutable during iteration.  This includes
  25. dicts, sets, and collections.deque.  Their implementation is equally simple
  26. though they need to permantently set their length to zero whenever there is
  27. an attempt to iterate after a length mutation.
  28.  
  29. The situation slightly more involved whenever an object allows length mutation
  30. during iteration.  Lists and sequence iterators are dynanamically updatable.
  31. So, if a list is extended during iteration, the iterator will continue through
  32. the new items.  If it shrinks to a point before the most recent iteration,
  33. then no further items are available and the length is reported at zero.
  34.  
  35. Reversed objects can also be wrapped around mutable objects; however, any
  36. appends after the current position are ignored.  Any other approach leads
  37. to confusion and possibly returning the same item more than once.
  38.  
  39. The iterators not listed above, such as enumerate and the other itertools,
  40. are not length transparent because they have no way to distinguish between
  41. iterables that report static length and iterators whose length changes with
  42. each call (i.e. the difference between enumerate('abc') and
  43. enumerate(iter('abc')).
  44.  
  45. """
  46. import unittest
  47. from test import test_support
  48. from itertools import repeat, count
  49. from collections import deque
  50. from UserList import UserList
  51. n = 10
  52.  
  53. class TestInvariantWithoutMutations(unittest.TestCase):
  54.     
  55.     def test_invariant(self):
  56.         it = self.it
  57.         for i in reversed(xrange(1, n + 1)):
  58.             self.assertEqual(len(it), i)
  59.             it.next()
  60.         
  61.         self.assertEqual(len(it), 0)
  62.         self.assertRaises(StopIteration, it.next)
  63.         self.assertEqual(len(it), 0)
  64.  
  65.  
  66.  
  67. class TestTemporarilyImmutable(TestInvariantWithoutMutations):
  68.     
  69.     def test_immutable_during_iteration(self):
  70.         it = self.it
  71.         self.assertEqual(len(it), n)
  72.         it.next()
  73.         self.assertEqual(len(it), n - 1)
  74.         self.mutate()
  75.         self.assertRaises(RuntimeError, it.next)
  76.         self.assertEqual(len(it), 0)
  77.  
  78.  
  79.  
  80. class TestRepeat(TestInvariantWithoutMutations):
  81.     
  82.     def setUp(self):
  83.         self.it = repeat(None, n)
  84.  
  85.     
  86.     def test_no_len_for_infinite_repeat(self):
  87.         self.assertRaises(TypeError, len, repeat(None))
  88.  
  89.  
  90.  
  91. class TestXrange(TestInvariantWithoutMutations):
  92.     
  93.     def setUp(self):
  94.         self.it = iter(xrange(n))
  95.  
  96.  
  97.  
  98. class TestXrangeCustomReversed(TestInvariantWithoutMutations):
  99.     
  100.     def setUp(self):
  101.         self.it = reversed(xrange(n))
  102.  
  103.  
  104.  
  105. class TestTuple(TestInvariantWithoutMutations):
  106.     
  107.     def setUp(self):
  108.         self.it = iter(tuple(xrange(n)))
  109.  
  110.  
  111.  
  112. class TestDeque(TestTemporarilyImmutable):
  113.     
  114.     def setUp(self):
  115.         d = deque(xrange(n))
  116.         self.it = iter(d)
  117.         self.mutate = d.pop
  118.  
  119.  
  120.  
  121. class TestDequeReversed(TestTemporarilyImmutable):
  122.     
  123.     def setUp(self):
  124.         d = deque(xrange(n))
  125.         self.it = reversed(d)
  126.         self.mutate = d.pop
  127.  
  128.  
  129.  
  130. class TestDictKeys(TestTemporarilyImmutable):
  131.     
  132.     def setUp(self):
  133.         d = dict.fromkeys(xrange(n))
  134.         self.it = iter(d)
  135.         self.mutate = d.popitem
  136.  
  137.  
  138.  
  139. class TestDictItems(TestTemporarilyImmutable):
  140.     
  141.     def setUp(self):
  142.         d = dict.fromkeys(xrange(n))
  143.         self.it = d.iteritems()
  144.         self.mutate = d.popitem
  145.  
  146.  
  147.  
  148. class TestDictValues(TestTemporarilyImmutable):
  149.     
  150.     def setUp(self):
  151.         d = dict.fromkeys(xrange(n))
  152.         self.it = d.itervalues()
  153.         self.mutate = d.popitem
  154.  
  155.  
  156.  
  157. class TestSet(TestTemporarilyImmutable):
  158.     
  159.     def setUp(self):
  160.         d = set(xrange(n))
  161.         self.it = iter(d)
  162.         self.mutate = d.pop
  163.  
  164.  
  165.  
  166. class TestList(TestInvariantWithoutMutations):
  167.     
  168.     def setUp(self):
  169.         self.it = iter(range(n))
  170.  
  171.     
  172.     def test_mutation(self):
  173.         d = range(n)
  174.         it = iter(d)
  175.         it.next()
  176.         it.next()
  177.         self.assertEqual(len(it), n - 2)
  178.         d.append(n)
  179.         self.assertEqual(len(it), n - 1)
  180.         d[1:] = []
  181.         self.assertEqual(len(it), 0)
  182.         self.assertEqual(list(it), [])
  183.         d.extend(xrange(20))
  184.         self.assertEqual(len(it), 0)
  185.  
  186.  
  187.  
  188. class TestListReversed(TestInvariantWithoutMutations):
  189.     
  190.     def setUp(self):
  191.         self.it = reversed(range(n))
  192.  
  193.     
  194.     def test_mutation(self):
  195.         d = range(n)
  196.         it = reversed(d)
  197.         it.next()
  198.         it.next()
  199.         self.assertEqual(len(it), n - 2)
  200.         d.append(n)
  201.         self.assertEqual(len(it), n - 2)
  202.         d[1:] = []
  203.         self.assertEqual(len(it), 0)
  204.         self.assertEqual(list(it), [])
  205.         d.extend(xrange(20))
  206.         self.assertEqual(len(it), 0)
  207.  
  208.  
  209.  
  210. class TestSeqIter(TestInvariantWithoutMutations):
  211.     
  212.     def setUp(self):
  213.         self.it = iter(UserList(range(n)))
  214.  
  215.     
  216.     def test_mutation(self):
  217.         d = UserList(range(n))
  218.         it = iter(d)
  219.         it.next()
  220.         it.next()
  221.         self.assertEqual(len(it), n - 2)
  222.         d.append(n)
  223.         self.assertEqual(len(it), n - 1)
  224.         d[1:] = []
  225.         self.assertEqual(len(it), 0)
  226.         self.assertEqual(list(it), [])
  227.         d.extend(xrange(20))
  228.         self.assertEqual(len(it), 0)
  229.  
  230.  
  231.  
  232. class TestSeqIterReversed(TestInvariantWithoutMutations):
  233.     
  234.     def setUp(self):
  235.         self.it = reversed(UserList(range(n)))
  236.  
  237.     
  238.     def test_mutation(self):
  239.         d = UserList(range(n))
  240.         it = reversed(d)
  241.         it.next()
  242.         it.next()
  243.         self.assertEqual(len(it), n - 2)
  244.         d.append(n)
  245.         self.assertEqual(len(it), n - 2)
  246.         d[1:] = []
  247.         self.assertEqual(len(it), 0)
  248.         self.assertEqual(list(it), [])
  249.         d.extend(xrange(20))
  250.         self.assertEqual(len(it), 0)
  251.  
  252.  
  253. if __name__ == '__main__':
  254.     unittests = [
  255.         TestRepeat,
  256.         TestXrange,
  257.         TestXrangeCustomReversed,
  258.         TestTuple,
  259.         TestDeque,
  260.         TestDequeReversed,
  261.         TestDictKeys,
  262.         TestDictItems,
  263.         TestDictValues,
  264.         TestSet,
  265.         TestList,
  266.         TestListReversed,
  267.         TestSeqIter,
  268.         TestSeqIterReversed]
  269.     test_support.run_unittest(*unittests)
  270.  
  271.